package com.example.cas.clientone.utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.*;


public class StringUtils {

    private static Logger logger = LoggerFactory.getLogger(StringUtils.class);
    private static final Calendar cal = Calendar.getInstance();

    /**
     * 字符串数字 格式转化数据 保留4为有效数字（四舍五入）
     *
     * @param floatNumber 数据
     * @return
     */
    public static String StringNumberFormant(float floatNumber) {
        String temp = "0";
        try {
            temp = new DecimalFormat("0.####").format(floatNumber);
        } catch (Exception ex) {
            logger.error("QuUtil StringNumberFormant 数据:" + floatNumber + " 强转错误!");
        }
        return temp;
    }

    /**
     * 字符串数字 格式转化数据 保留4为有效数字（四舍五入）
     *
     * @param strNumber 数据
     * @return
     */
    public static String StringNumberFormant(String strNumber) {
        String temp = "0";
        try {
            temp = new DecimalFormat("0.####").format(Float.parseFloat(strNumber));
        } catch (Exception ex) {
            logger.error("QuUtil StringNumberFormant 数据:" + strNumber + " 强转错误!");
        }
        return temp;
    }

    /**
     * 字符串数字 格式转化数据 保留4为有效数字（四舍五入）
     *
     * @param strNumber 数据
     * @param format    格式化 例如:(0.####/0.##/0.0000)
     * @return
     */
    public static String StringNumberFormant(String strNumber, String format) {
        String temp = "0";
        try {
            temp = new DecimalFormat(format).format(Float.parseFloat(strNumber));
        } catch (Exception ex) {
            logger.error("QuUtil StringNumberFormant 格式:" + format + " 数据:" + strNumber + " 强转错误!");
        }
        return temp;
    }

    /**
     * 判断一个字符串是否为空或空字符串
     *
     * @param str
     * @return 如果str==null或str==""返回true否则返回false
     */
    public static boolean isEmpty(String str) {
        return str == null || "".equals(str) || "undefined".equals(str) || "null".equals(str);
    }
    public static boolean isEmpty(Object str) {
        return str == null || "".equals(str) || "undefined".equals(str) || "null".equals(str);
    }

    /**
     * 去除str的前空格后空格
     *
     * @param str
     * @return 如果str==null返回null否则返回str.trim()
     */
    public static String trim(String str) {
        if (str == null) {
            return null;
        }
        return str.trim();
    }

    public static boolean isNotEmptyObject(Object object) {
        if (object == null || "".equals((object + "").trim()) || "null".equals((object + "").trim()) || "undefined".equals((object + "").trim())) {
            return false;
        } else {
            return true;
        }
    }

    public static String getStringByObj(Object obj) {
        if (obj == null || "".equals((obj + "").trim()) || "undefined".equals(obj) || "null".equals((obj + "").trim())) {
            return "";
        }
        return obj + "";
    }
    public static String getStringByObj(Object obj, String defaultValue) {
        String temp=getStringByObj(obj);
        if("".equals(temp)){
            temp=defaultValue;
        }
        return temp;
    }

    /**
     * 根据对象 转成Integer
     *
     * @param obj
     * @return
     */
    public static Integer getIntegerByObj(Object obj) {
        if (obj == null || "".equals((obj + "").trim()) || "undefined".equals(obj) || "null".equals((obj + "").trim())) {
            return 0;
        }
        return Integer.parseInt(obj + "");
    }

    public static Integer getIntegerByObj(Object obj, Integer defaultValue) {
        Integer temp=getIntegerByObj(obj);
        if(temp==0){
            temp=defaultValue;
        }
        return temp;
    }
    /**
     * 根据对象 转成Float
     *
     * @param obj
     * @return
     */
    public static Float getFloatByObj(Object obj) {
        if (obj == null || "".equals((obj + "").trim()) || "undefined".equals(obj) || "null".equals((obj + "").trim())) {
            return 0f;
        }
        return Float.parseFloat(obj + "");
    }

    /**
     * 根据对象 转成Long
     *
     * @param obj
     * @return
     */
    public static Long getLongByObj(Object obj) {
        if (obj == null || "".equals((obj + "").trim()) || "undefined".equals(obj) || "null".equals((obj + "").trim())) {
            return 0l;
        }
        return Long.parseLong(obj + "");
    }

    /**
     * 数字字符串加一，不限长度。
     *
     * @param str
     * @return
     */
    public static String strAddOne(String str) {
        double t = Math.pow(10, str.length());
        double t2 = Math.pow(10, -str.length());
        String s = String.valueOf(Math.round((Integer.valueOf(str) / t + t2) * t));
        int l = str.length() - s.length();
        for (int i = 0; i < l; i++) {
            s = "0" + s;
        }
        return s;
    }


    /**
     * 计算百分比
     *
     * @param num
     * @param total
     * @param scale
     * @return
     */
    public static String accuracy(double num, double total, int scale) {
        if (total == 0.0) {
            return "";
        }
        DecimalFormat df = (DecimalFormat) NumberFormat.getInstance();
        //可以设置精确几位小数
        df.setMaximumFractionDigits(scale);
        //模式 例如四舍五入
        df.setRoundingMode(RoundingMode.HALF_UP);
        double accuracy_num = num / total * 100;
        return df.format(accuracy_num) + "%";
    }

    /**
     * 计算百分比
     *
     * @param num
     * @param total
     * @param scale
     * @return
     */
    public static String accuracyTwo(double num, double total, int scale) {
        if (total == 0.0) {
            return "";
        }
        DecimalFormat df = (DecimalFormat) NumberFormat.getInstance();
        //可以设置精确几位小数
        df.setMaximumFractionDigits(scale);
        //模式 例如四舍五入
        df.setRoundingMode(RoundingMode.HALF_UP);
        double accuracy_num = num / total * 100;
        return df.format(accuracy_num);
    }

    /**
     * @Description:把数组转换为一个用逗号分隔的字符串 ，以便于用in+String 查询
     */
    public static String converToString(String[] ig) {
        String str = "";
        if (ig != null && ig.length > 0) {
            for (int i = 0; i < ig.length; i++) {
                str += ig[i] + ",";
            }
        }
        str = str.substring(0, str.length() - 1);
        return str;
    }

    /**
     * @Description:把list转换为一个用逗号分隔的字符串
     */
    public static String listToString(List list) {
        StringBuilder sb = new StringBuilder();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                if (i < list.size() - 1) {
                    sb.append(list.get(i) + ",");
                } else {
                    sb.append(list.get(i));
                }
            }
        }
        return sb.toString();
    }

    /**
     * 将企业的小类翻译成大类
     *
     * @param code
     * @return
     */
    //公司类型   100以上 不在统计范围之内
    //药品     1：药品零售企业 2：药品批发企业 3：药品生产企业 4：医疗机构 23：幼儿园保健室    101:药品零售选址  102：药品零售筹建
    //餐饮     5：餐饮企业 6：学校企事业建筑 7：固定地点小餐饮 8：农家乐基本信息 9：便民餐饮小摊点
    //食品     10：食品流通企业 11：食品生产企业 12：生产加工小作坊 13：农产品农贸市场 14：小食品店 15：添加剂经营企业 16：添加剂生产企业
    //         24:食品经营许可证
    //医疗器械  17：经营企业 18:生产企业
    //保健食品  19：经营企业 20:生产企业
    //化妆品    21：经营企业 22:生产企业
    //检疫检测    25：动物检疫检测
    public static String getComBigTypeByComType(String code) {
        code = "," + code + ",";
        String tempType = "";
        if (code.contains(",1,")) {
            tempType = "1";
        } else if (code.contains(",2,")) {
            tempType = "1";
        } else if (code.contains(",3,")) {
            tempType = "1";
        } else if (code.contains(",4,")) {
            tempType = "1";
        } else if (code.contains(",23,")) {
            tempType = "1";
        } else if (code.contains(",27,")) {
            tempType = "1";
        } else if (code.contains(",5")) {
            tempType = "7";
        } else if (code.contains(",6,")) {
            tempType = "7";
        } else if (code.contains(",7,")) {
            tempType = "7";
        } else if (code.contains(",8,")) {
            tempType = "7";
        } else if (code.contains(",9,")) {
            tempType = "7";
        } else if (code.contains(",10,")) {
            tempType = "6";
        } else if (code.contains(",11")) {
            tempType = "8";
        } else if (code.contains(",12,")) {
            tempType = "8";
        } else if (code.contains(",13,")) {
            tempType = "6";
        } else if (code.contains(",14,")) {
            tempType = "6";
        } else if (code.contains(",15,")) {
            tempType = "6";
        } else if (code.contains(",16,")) {
            tempType = "8";
        } else if (code.contains(",17,")) {
            tempType = "3";
        } else if (code.contains(",18,")) {
            tempType = "3";
        }else if (code.contains(",26,")) {
            tempType = "3";
        } else if (code.contains(",19,")) {
            tempType = "4";
        } else if (code.contains(",20,")) {
            tempType = "4";
        } else if (code.contains(",21,")) {
            tempType = "5";
        } else if (code.contains(",22,")) {
            tempType = "5";
        }

        return tempType;
    }
    public static Map<String, Object> transBean2Map(Object obj) {

        if(obj == null){
            return null;
        }
        Map<String, Object> map = new HashMap<String, Object>();
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor property : propertyDescriptors) {
                String key = property.getName();

                // 过滤class属性
                if (!key.equals("class")) {
                    // 得到property对应的getter方法
                    Method getter = property.getReadMethod();
                    Object value = getter.invoke(obj);

                    map.put(key, value);
                }

            }
        } catch (Exception e) {
            logger.error("transBean2Map Error " + e);
        }

        return map;

    }

    /**
     * 根据企业大类获取小类
     *
     * @param codeStr
     * @return
     */
    //公司类型   100以上 不在统计范围之内
    //药品     1：药品零售企业 2：药品批发企业 3：药品生产企业 4：医疗机构 23：幼儿园保健室    101:药品零售选址  102：药品零售筹建
    //餐饮     5：餐饮企业 6：学校企事业建筑 7：固定地点小餐饮 8：农家乐基本信息 9：便民餐饮小摊点
    //食品     10：食品流通企业 11：食品生产企业 12：生产加工小作坊 13：农产品农贸市场 14：小食品店 15：添加剂经营企业 16：添加剂生产企业
    //         24:食品经营许可证
    //医疗器械  17：经营企业 18:生产企业
    //保健食品  19：经营企业 20:生产企业
    //化妆品    21：经营企业 22:生产企业
    //检疫检测    25：动物检疫检测
    public static List<Integer> getEnterpriseTypeByComType(String codeStr) {
        List<Integer> enterpriseTypes = new ArrayList<Integer>();
        String[] codes = codeStr.split(",");
        for(String code : codes){
            switch (Integer.valueOf(code)){
                case 1:
                    enterpriseTypes.add(1);
                    enterpriseTypes.add(2);
                    enterpriseTypes.add(3);
                    enterpriseTypes.add(4);
                    enterpriseTypes.add(23);
                break;
                case 3:
                    enterpriseTypes.add(17);
                    enterpriseTypes.add(18);
                break;
                case 4:
                    enterpriseTypes.add(19);
                    enterpriseTypes.add(20);
                break;
                case 5:
                    enterpriseTypes.add(21);
                    enterpriseTypes.add(22);
                break;
                case 6:
                    enterpriseTypes.add(10);
                    enterpriseTypes.add(13);
                    enterpriseTypes.add(14);
                    enterpriseTypes.add(15);
                break;
                case 7:
                    enterpriseTypes.add(5);
                    enterpriseTypes.add(6);
                    enterpriseTypes.add(7);
                    enterpriseTypes.add(8);
                    enterpriseTypes.add(9);
                break;
                case 8:
                    enterpriseTypes.add(11);
                    enterpriseTypes.add(12);
                    enterpriseTypes.add(16);
                break;
            }
        }
        return enterpriseTypes;
    }

    /**
     * 字符串数组转换成逗号相隔字符串
     * @param selectOptions
     * @param c
     * @return
     */
    public static Object join(int [] selectOptions, String c) {
        String result = "";
        for (int string : selectOptions) {
            result += string+"" + c;
        }
        return result.replaceAll(c + "$", "");
    }

    public static String joinSplit(List<?> enterpriseTypes) {
        String result = "";
        for (Object object : enterpriseTypes) {
            result += object.toString()+",";
        }
        return result.substring(0, result.lastIndexOf(","));
    }

    public static boolean FIND_IN_SET(String str, String strlist){
        return FIND_IN_SET(str,strlist,",");
    }
    public static boolean FIND_IN_SET(String str, String strlist, String biaoJi){
        if(StringUtils.isEmpty(str)|| StringUtils.isEmpty(strlist)){
            return false;
        }
        if((biaoJi+strlist+biaoJi).indexOf(biaoJi+str+biaoJi)>-1){
            return true;
        }else{
            return false;
        }
    }


    /**
     * 拼接字符串 默认根据“，”拼接
     * @param str1
     * @param str2
     * @return
     */
    public static String getStringConcat(String str1, String str2) {
        return  getStringConcat(str1,str2,",",false);
    }
    /**
     * 拼接字符串 默认根据“，”拼接
     * @param str1
     * @param str2
     * @return
     */
    public static String getStringConcat(String str1, String str2, boolean isDistinct) {
        return  getStringConcat(str1,str2,",",isDistinct);
    }

    /**
     * 拼接字符串  根据perFix参数处理
     * @param str1
     * @param str2
     * @param perFix
     * @return
     */
    public static String getStringConcat(String str1, String str2, String perFix) {
        return  getStringConcat(str1,str2,",",false);
    }
    /**
     * 拼接字符串  根据perFix参数处理
     * @param str1
     * @param str2
     * @param perFix
     * @return
     */
    public static String getStringConcat(String str1, String str2, String perFix, boolean isDistinct) {
        str1=getStringByObj(str1);
        str2=getStringByObj(str2);
        if(isDistinct){
            if((perFix+str1+perFix).indexOf(perFix+str2+perFix)>-1){
                return str1;
            }
        }
        if(StringUtils.isNotEmptyObject(str1)&& StringUtils.isNotEmptyObject(str2)){
            str1+=perFix;
        }
        str1+=str2;
        return str1;
    }

    public static String getShortOrgName(String orgName) {
        return getStringByObj(orgName).replaceAll("^(.{2}.*?)((卫生食品药品监.*)|(食品药品监.*)|(食药监.*)|(市场监.*)|(分局.*)|(市场和质量.*)|(街道办事处.*))?$","$1");
    }


    /*public static void main(String[] args) {
        logger.error(accuracy(3, 11, 1));
    }*/

    /**
     * 数组去重
     * @param array
     * @return
     */
    public static String[] arrayRemoveRepeat(String[] array){

        List<String> list = new ArrayList<>();
        for (int i=0; i<array.length; i++) {
            if(!list.contains(array[i])) {
                list.add(array[i]);
            }
        }

        String[] arrayResult = list.toArray(new String[list.size()]);
        return  arrayResult;
    }

    /**
     * 判断是否是数字
     * @param str
     * @return
     */
    public static boolean isNumeric(String str){
        for (int i = 0; i < str.length(); i++){
            if (!Character.isDigit(str.charAt(i))){
                return false;
            }
        }
        return true;
    }

}
